{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 使用ModelScope ViT模型完成图像分类模型微调和部署\n",
    "\n",
    "## 背景介绍\n",
    "\n",
    "\n",
    "[ModelScope](https://www.modelscope.cn)是一个旨在为泛AI开发者提供灵活、易用、低成本的一站式“模型即服务”（MaaS）的开源平台。它汇集了丰富的预训练模型，覆盖了NLP、CV、Audio、AIGC、多模态大模型等多个领域。利用ModelScope所提供的模型以及ModelScope Library，开发者可以用一行代码实现模型推理，或者用十几行代码实现对预训练模型的调优训练，方便开发者基于行业数据集快速构建专属行业模型。\n",
    "\n",
    "当前示例中，我们以[ViT图像分类-通用](https://modelscope.cn/models/damo/cv_vit-base_image-classification_ImageNet-labels/summary) 为示例，展示如何在PAI完成一个ModelScope模型的微调训练，然后将获得的模型部署为一个在线推理服务的过程。主要流程包括：\n",
    "\n",
    "1. 准备工作：\n",
    "\n",
    "安装PAI Python SDK，并完成SDK配置。\n",
    "\n",
    "2. 模型的微调训练\n",
    "\n",
    "编写微调训练脚本，使用[花朵分类](https://www.modelscope.cn/models/zydfx1111/flower)对模型进行微调，使用PAI Python SDK将训练脚本提交到PAI执行。\n",
    "\n",
    "3. 部署推理服务\n",
    "\n",
    "将微调训练作业输出的模型，部署到PAI-EAS，创建一个在线推理服务。\n",
    "\n",
    "## 前提条件\n",
    "\n",
    "- 已获取阿里云账号的鉴权AccessKey ID和AccessKey Secret，详情请参见：[获取AccessKey](https://help.aliyun.com/document_detail/116401.html)。\n",
    "- 已创建或是加入一个PAI AI工作空间，详情请参见：[创建工作空间](https://help.aliyun.com/document_detail/326193.html)。\n",
    "- 已创建OSS Bucket，详情请参见：[控制台创建存储空间](https://help.aliyun.com/document_detail/31885.html)。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## 费用说明\n",
    "\n",
    "本示例将会使用以下云产品，并产生相应的费用账单：\n",
    "\n",
    "- PAI-DLC：运行训练任务，详细计费说明请参考[PAI-DLC计费说明](https://help.aliyun.com/zh/pai/product-overview/billing-of-dlc)\n",
    "- PAI-EAS：部署推理服务，详细计费说明请参考[PAI-EAS计费说明](https://help.aliyun.com/zh/pai/product-overview/billing-of-eas)\n",
    "- OSS：存储训练任务输出的模型、训练代码、TensorBoard日志等，详细计费说明请参考[OSS计费概述](https://help.aliyun.com/zh/oss/product-overview/billing-overview)\n",
    "\n",
    "\n",
    "> 通过参与云产品免费试用，使用**指定资源机型**提交训练作业或是部署推理服务，可以免费试用PAI产品，具体请参考[PAI免费试用](https://help.aliyun.com/zh/pai/product-overview/free-quota-for-new-users)。\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step1: 准备工作\n",
    "\n",
    "我们将使用PAI提供的PythonSDK，提交训练作业，部署模型。可以通过以下命令安装PAI Python SDK。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python -m pip install -U pai"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "SDK需要配置访问阿里云服务需要的 AccessKey，以及当前使用的工作空间和OSS Bucket。在PAI Python SDK安装之后，通过在 **命令行终端** 中执行以下命令，按照引导配置密钥，工作空间等信息。\n",
    "\n",
    "\n",
    "```shell\n",
    "\n",
    "# 以下命令，请在 命令行终端 中执行.\n",
    "\n",
    "python -m pai.toolkit.config\n",
    "\n",
    "```\n",
    "\n",
    "我们可以通过以下代码验证当前的配置。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pai\n",
    "from pai.session import get_default_session\n",
    "\n",
    "print(pai.__version__)\n",
    "sess = get_default_session()\n",
    "\n",
    "assert sess.workspace_name is not None\n",
    "print(sess.workspace_name)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step2: 提交微调训练作业\n",
    "\n",
    "ModelScope的[ViT图片分类-通用](https://modelscope.cn/models/damo/cv_vit-base_image-classification_ImageNet-labels/summary)模型使用经典的[ViT Base](https://github.com/google-research/vision_transformer)模型结构，在ImageNet-1k数据集进行预训练，可以直接用于[ImageNet 1k标签](https://deeplearning.cms.waikato.ac.nz/user-guide/class-maps/IMAGENET/)覆盖图像的分类任务，也可以作为下游任务的预训练模型。\n",
    "\n",
    "当前示例，我们将以[花朵分类数据集](https://www.modelscope.cn/datasets/tany0699/flowers14/summary)对模型进行微调训练，从而获得一个可以用于花朵分类的模型。\n",
    "\n",
    "### 准备微调训练脚本\n",
    "\n",
    "ModelScope提供了功能完善的Python Library，能够支持用户方便得使用ModelScope模型进行推理以及微调训练，在本示例中，我们将使用ModelScope Library编写相应的微调训练脚本，然后提交到PAI执行微调训练作业。\n",
    "\n",
    "\n",
    "准备训练代码目录，其中包含训练使用的作业脚本以及训练依赖的第三方库。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# 准备相应训练作业脚本目录\n",
    "!mkdir -p train_src"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "完整的微调训练脚本代码如下：\n",
    "\n",
    "> 对于ModelScope library的使用介绍，请参见：[ModelScope文档](https://www.modelscope.cn/docs/ModelScope%20Library%E6%A6%82%E8%A7%88%E4%BB%8B%E7%BB%8D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting train_src/finetune.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile train_src/finetune.py\n",
    "\n",
    "import os\n",
    "import re\n",
    "import logging\n",
    "import shutil\n",
    "\n",
    "\n",
    "from modelscope.msdatasets import MsDataset\n",
    "from modelscope.metainfo import Trainers\n",
    "from modelscope.trainers import build_trainer\n",
    "\n",
    "\n",
    "# 从环境变量中获取超参（由PAI的训练服务注入）\n",
    "BATCH_SIZE = int(os.environ.get(\"PAI_HPS_BATCH_SIZE\", 16))\n",
    "LEARNING_RATE = float(os.environ.get(\"PAI_HPS_INITIAL_LEARNING_RATE\", 1e-3))\n",
    "NUM_EPOCHS = int(os.environ.get(\"PAI_HPS_EPOCHS\", 1))\n",
    "NUM_CLASSES = int(os.environ.get(\"PAI_HPS_NUM_CLASSES\", 14))\n",
    "MODEL_ID_OR_PATH = os.environ.get(\"PAI_INPUT_MODEL\", \"damo/cv_vit-base_image-classification_ImageNet-labels\")\n",
    "\n",
    "OUTPUT_MODEL_DIR = os.environ.get(\"PAI_OUTPUT_MODEL\", \"./model/\")\n",
    "WORK_DIR = os.environ.get(\"PAI_OUTPUT_CHECKPOINTS\", \"./checkpoints/\")\n",
    "\n",
    "\n",
    "# 将产出的模型保存到模型输出目录(OUTPUT_MODEL_DIR)\n",
    "def save_model():\n",
    "    best_ckpt_pattern = re.compile(\n",
    "        pattern=r\"^best_accuracy_top-1_epoch_\\d+.pth$\"\n",
    "    )\n",
    "    print(\"Saving best checkpoint as pytorch_model.pt\")\n",
    "    print(\"List work dir: \", os.listdir(WORK_DIR))\n",
    "\n",
    "    f_name = next((f for f in os.listdir(WORK_DIR) if best_ckpt_pattern.match(f)), None)\n",
    "    if f_name:\n",
    "        # 使用最佳checkpoints作为输出模型\n",
    "        print(\"Found best checkpoint: \", f_name)\n",
    "        shutil.copyfile(\n",
    "            src=os.path.join(WORK_DIR, f_name),\n",
    "            dst=os.path.join(OUTPUT_MODEL_DIR, \"pytorch_model.pt\"),\n",
    "        )\n",
    "        os.remove(os.path.join(WORK_DIR, f_name))\n",
    "    else:\n",
    "        # 如果没有，则使用最后一个epoch的checkpoints作为输出模型\n",
    "        print(\"Not found best checkpoint.\")\n",
    "        last_ckpt_file = \"epoch_{}.pth\".format(NUM_EPOCHS)\n",
    "        if os.path.isfile(os.path.join(WORK_DIR, last_ckpt_file)):\n",
    "            shutil.copyfile(\n",
    "                src=os.path.join(WORK_DIR, last_ckpt_file),\n",
    "                dst=os.path.join(OUTPUT_MODEL_DIR, \"pytorch_model.pt\"),\n",
    "            )\n",
    "    # 模型配置信息\n",
    "    shutil.copyfile(\n",
    "        src=os.path.join(WORK_DIR, \"configuration.json\"),\n",
    "        dst=os.path.join(OUTPUT_MODEL_DIR, \"configuration.json\"),\n",
    "    )\n",
    "\n",
    "\n",
    "# 修改配置文件\n",
    "def cfg_modify_fn(cfg):\n",
    "    cfg.train.dataloader.batch_size_per_gpu = BATCH_SIZE # batch大小\n",
    "    cfg.train.dataloader.workers_per_gpu = 8     # 每个gpu的worker数目\n",
    "    cfg.train.max_epochs = 1                     # 最大训练epoch数\n",
    "    cfg.model.mm_model.head.num_classes = NUM_CLASSES                       # 分类数\n",
    "    cfg.model.mm_model.train_cfg.augments[0].num_classes = NUM_CLASSES      # 分类数\n",
    "    cfg.model.mm_model.train_cfg.augments[1].num_classes = NUM_CLASSES      # 分类数\n",
    "    cfg.train.optimizer.lr = LEARNING_RATE                # 学习率\n",
    "    cfg.train.lr_config.warmup_iters = 1         # 预热次数\n",
    "\n",
    "    # Note: OSS挂载到输出路径中，不支持软链接.\n",
    "    cfg.train.checkpoint_config.create_symlink = False\n",
    "    return cfg\n",
    "\n",
    "\n",
    "ms_train_dataset = MsDataset.load(\n",
    "            'flowers14', namespace='tany0699',\n",
    "            subset_name='default', split='train') # 加载训练集\n",
    "\n",
    "ms_val_dataset = MsDataset.load(\n",
    "            'flowers14', namespace='tany0699',\n",
    "            subset_name='default', split='validation') # 加载验证集\n",
    "\n",
    "\n",
    "# 构建训练器\n",
    "kwargs = dict(\n",
    "    model=MODEL_ID_OR_PATH,                 # 模型id\n",
    "    work_dir=WORK_DIR,\n",
    "    train_dataset=ms_train_dataset, # 训练集  \n",
    "    eval_dataset=ms_val_dataset,    # 验证集\n",
    "    cfg_modify_fn=cfg_modify_fn     # 用于修改训练配置文件的回调函数\n",
    "    )\n",
    "trainer = build_trainer(name=Trainers.image_classification, default_args=kwargs)\n",
    "\n",
    "# 进行训练\n",
    "trainer.train()\n",
    "\n",
    "# 进行评估\n",
    "result = trainer.evaluate()\n",
    "print('Evaluation Result:', result)\n",
    "\n",
    "# 保存模型\n",
    "save_model()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "完整的训练作业脚本目录结构如下：\n",
    "\n",
    "```shell\n",
    "\n",
    "train_src\n",
    "    └── finetune.py\n",
    "\n",
    "```\n",
    "\n",
    "后续我们将通过PAI Python SDK将训练脚本提交到PAI执行。\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 提交训练作业到PAI\n",
    "\n",
    "SDK提供了High-Level的API，`pai.modelscope.ModelScopeEstimator`，支持用户方便地使用预置的ModelScope镜像，提交训练作业到PAI。以下代码中，我们将使用以上的训练作业脚本（`train_src`目录），配合PAI提供预置训练镜像，提交训练作业。\n",
    "\n",
    "对于如何使用SDK提交训练作业的详细介绍，可以见文档：[提交训练作业](https://help.aliyun.com/document_detail/2261505.html)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pai.modelscope import ModelScopeEstimator\n",
    "from pai.image import retrieve\n",
    "\n",
    "\n",
    "# 使用训练配置信息，创建Estimator对象\n",
    "est = ModelScopeEstimator(\n",
    "    command=\"python finetune.py\",  # 训练作业的启动命令\n",
    "    source_dir=\"train_src\",  # 训练作业脚本本地目录（绝对路径，或是相对路径）\n",
    "    modelscope_version=\"1.11.0\",\n",
    "    instance_type=\"ecs.gn6e-c12g1.3xlarge\",  # 12vCPU 92GiB NVIDIA V100 × 1， 作业使用的机器规格\n",
    "    base_job_name=\"vit-finetune\",  # 作业名称\n",
    "    hyperparameters={  # 训练作业超参，用户可以通过环境变量或是读取配置文件的方式获取.\n",
    "        \"batch_size\": 128,\n",
    "        \"initial_learning_rate\": 1e-4,\n",
    "        \"epochs\": 2,\n",
    "        # 花朵数据集一共14个分类\n",
    "        \"num_classes\": 14,\n",
    "    },\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过`fit` API提交训练作业。当前示例中，我们在训练脚本中使用ModelScope的library去下载数据集。当用户需要使用自定义数据集时，可以通过`fit`方法传递相应数据OSS路径，训练作业会通过挂载的方式将相应的数据准备的执行环境中。\n",
    "\n",
    "在PAI的执行环境中，用户的训练作业脚本可以通过环境变量 `PAI_INPUT_{ChannelNameUpperCase}` 获得数据的本地路径，其中`{ChannelNameUpperCase}`是数据通道的名称，例如`train`。\n",
    "\n",
    "```python\n",
    "\n",
    "est.fit(\n",
    "\t# 用户的训练作业脚本可以通过环境变量 PAI_INPUT_{ChannelNameUpperCase} 获得数据的本地路径.\n",
    "\t\"train\": \"oss://<your-bucket>/train/data/path/\",\n",
    ")\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TrainingJob launch starting\n",
      "LIBRARY_PATH=/usr/local/cuda/lib64/stubs\n",
      "DSW_95221_PORT_22_TCP_PROTO=tcp\n",
      "DSW_95221_SERVICE_PORT_SSH_DSW_95221=22\n",
      "DSW_95221_PORT_80_TCP_ADDR=10.192.9.246\n",
      "NV_CUDA_COMPAT_PACKAGE=cuda-compat-12-1\n",
      "NV_LIBCUBLAS_VERSION=12.1.0.26-1\n",
      "NV_NVPROF_DEV_PACKAGE=cuda-nvprof-12-1=12.1.55-1\n",
      "KUBERNETES_SERVICE_PORT=6443\n",
      "KUBERNETES_PORT=tcp://10.192.0.1:443\n",
      "NV_CUDA_NSIGHT_COMPUTE_VERSION=12.1.0-1\n",
      "LANGUAGE=zh_CN.UTF-8\n",
      "PIP_TRUSTED_HOST=mirrors.cloud.aliyuncs.com\n",
      "SCRAPE_PROMETHEUS_METRICS=yes\n",
      "MASTER_ADDR=train137j6rqoh43-master-0\n",
      "DSW_95221_PORT_80_TCP_PORT=80\n",
      "HOSTNAME=train137j6rqoh43-master-0\n",
      "DSW_98084_PORT=tcp://10.192.30.20:80\n",
      "DSW_95221_PORT_80_TCP_PROTO=tcp\n",
      "DSW_95221_SERVICE_PORT_HTTP_DSW_95221=80\n",
      "DSW_98084_SERVICE_PORT=80\n",
      "LD_LIBRARY_PATH=/usr/local/nvidia/lib:/usr/local/nvidia/lib64\n",
      "NV_LIBNCCL_PACKAGE_VERSION=2.17.1-1\n",
      "NVIDIA_CUDA_END_OF_LIFE=1\n",
      "DSW_107274_PORT=tcp://10.192.12.78:80\n",
      "DSW_107274_SERVICE_PORT=80\n",
      "MASTER_PORT=23456\n",
      "DSW_98084_PORT_22_TCP_ADDR=10.192.30.20\n",
      "DSW_96358_SERVICE_PORT=80\n",
      "DSW_96358_PORT=tcp://10.192.28.168:80\n",
      "HOME=/root\n",
      "NV_LIBCUBLAS_DEV_VERSION=12.1.0.26-1\n",
      "NV_CUDNN_PACKAGE_NAME=libcudnn8\n",
      "DSW_107274_PORT_22_TCP_ADDR=10.192.12.78\n",
      "PAI_USER_ARGS=--initial_learning_rate 0.0001 --epochs 2 --num_classes 14 --batch_size 128\n",
      "PYTHONUNBUFFERED=0\n",
      "DSW_95221_PORT_22_TCP=tcp://10.192.9.246:22\n",
      "DSW_96358_PORT_22_TCP_ADDR=10.192.28.168\n",
      "NPROC_PER_NODE=1\n",
      "DSW_98084_PORT_22_TCP_PORT=22\n",
      "PAI_CONFIG_DIR=/ml/input/config/\n",
      "PAI_OUTPUT_CHECKPOINTS=/ml/output/checkpoints/\n",
      "WORLD_SIZE=1\n",
      "DSW_107274_PORT_22_TCP_PORT=22\n",
      "DSW_98084_PORT_80_TCP_ADDR=10.192.30.20\n",
      "DSW_98084_PORT_22_TCP_PROTO=tcp\n",
      "NV_LIBNCCL_DEV_PACKAGE_VERSION=2.17.1-1\n",
      "REGION_ID=cn-hangzhou\n",
      "DSW_107274_PORT_22_TCP_PROTO=tcp\n",
      "DSW_96358_PORT_22_TCP_PORT=22\n",
      "DSW_107274_PORT_80_TCP_ADDR=10.192.12.78\n",
      "NV_LIBNPP_PACKAGE=libnpp-12-1=12.0.2.50-1\n",
      "DSW_96358_PORT_80_TCP_ADDR=10.192.28.168\n",
      "DSW_96358_PORT_22_TCP_PROTO=tcp\n",
      "DSW_95221_PORT_80_TCP=tcp://10.192.9.246:80\n",
      "CUDA_VERSION=12.1.0\n",
      "NV_CUDNN_PACKAGE=libcudnn8=8.9.0.131-1+cuda12.1\n",
      "RANK=0\n",
      "DSW_98084_PORT_80_TCP_PORT=80\n",
      "NV_NVPROF_VERSION=12.1.55-1\n",
      "DSW_98084_PORT_80_TCP_PROTO=tcp\n",
      "DSW_107274_PORT_80_TCP_PORT=80\n",
      "NV_LIBCUBLAS_PACKAGE_NAME=libcublas-12-1\n",
      "DSW_107274_PORT_80_TCP_PROTO=tcp\n",
      "DSW_96358_PORT_80_TCP_PORT=80\n",
      "PAI_HPS_NUM_CLASSES=14\n",
      "NVIDIA_REQUIRE_CUDA=cuda>=12.1 brand=tesla,driver>=450,driver<451 brand=tesla,driver>=470,driver<471 brand=unknown,driver>=470,driver<471 brand=nvidia,driver>=470,driver<471 brand=nvidiartx,driver>=470,driver<471 brand=geforce,driver>=470,driver<471 brand=geforcertx,driver>=470,driver<471 brand=quadro,driver>=470,driver<471 brand=quadrortx,driver>=470,driver<471 brand=titan,driver>=470,driver<471 brand=titanrtx,driver>=470,driver<471 brand=tesla,driver>=510,driver<511 brand=unknown,driver>=510,driver<511 brand=nvidia,driver>=510,driver<511 brand=nvidiartx,driver>=510,driver<511 brand=geforce,driver>=510,driver<511 brand=geforcertx,driver>=510,driver<511 brand=quadro,driver>=510,driver<511 brand=quadrortx,driver>=510,driver<511 brand=titan,driver>=510,driver<511 brand=titanrtx,driver>=510,driver<511 brand=tesla,driver>=515,driver<516 brand=unknown,driver>=515,driver<516 brand=nvidia,driver>=515,driver<516 brand=nvidiartx,driver>=515,driver<516 brand=geforce,driver>=515,driver<516 brand=geforcertx,driver>=515,driver<516 brand=quadro,driver>=515,driver<516 brand=quadrortx,driver>=515,driver<516 brand=titan,driver>=515,driver<516 brand=titanrtx,driver>=515,driver<516 brand=tesla,driver>=525,driver<526 brand=unknown,driver>=525,driver<526 brand=nvidia,driver>=525,driver<526 brand=nvidiartx,driver>=525,driver<526 brand=geforce,driver>=525,driver<526 brand=geforcertx,driver>=525,driver<526 brand=quadro,driver>=525,driver<526 brand=quadrortx,driver>=525,driver<526 brand=titan,driver>=525,driver<526 brand=titanrtx,driver>=525,driver<526\n",
      "arch=x86_64\n",
      "TENANT_API_SERVER_URL=https://10.224.148.12:6443\n",
      "DSW_96358_PORT_80_TCP_PROTO=tcp\n",
      "NVIDIA_DRIVER_CAPABILITIES=compute,utility\n",
      "NV_CUDA_LIB_VERSION=12.1.0-1\n",
      "NV_LIBCUSPARSE_VERSION=12.0.2.55-1\n",
      "NV_LIBNCCL_PACKAGE_NAME=libnccl2\n",
      "PAI_TRAINING_JOB_ID=train137j6rqoh43\n",
      "PAI_HPS_INITIAL_LEARNING_RATE=0.0001\n",
      "PAI_OUTPUT_TENSORBOARD=/ml/output/tensorboard/\n",
      "NV_NVML_DEV_VERSION=12.1.55-1\n",
      "NV_LIBNPP_DEV_PACKAGE=libnpp-dev-12-1=12.0.2.50-1\n",
      "VLLM_USE_MODELSCOPE=True\n",
      "DSW_98084_PORT_22_TCP=tcp://10.192.30.20:22\n",
      "NV_CUDA_CUDART_VERSION=12.1.55-1\n",
      "NV_CUDNN_PACKAGE_DEV=libcudnn8-dev=8.9.0.131-1+cuda12.1\n",
      "KUBERNETES_PORT_443_TCP_ADDR=10.192.0.1\n",
      "DSW_107274_PORT_22_TCP=tcp://10.192.12.78:22\n",
      "PAI_OUTPUT_MODEL=/ml/output/model/\n",
      "DSW_96358_PORT_22_TCP=tcp://10.192.28.168:22\n",
      "DSW_98084_SERVICE_PORT_SSH_DSW_98084=22\n",
      "PATH=/opt/conda/bin:/usr/local/nvidia/bin:/usr/local/cuda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin\n",
      "NVARCH=x86_64\n",
      "NV_LIBCUBLAS_PACKAGE=libcublas-12-1=12.1.0.26-1\n",
      "NV_LIBCUBLAS_DEV_PACKAGE_NAME=libcublas-dev-12-1\n",
      "PIP_INDEX_URL=https://mirrors.cloud.aliyuncs.com/pypi/simple\n",
      "KUBERNETES_PORT_443_TCP_PORT=443\n",
      "DSW_107274_SERVICE_PORT_SSH_DSW_107274=22\n",
      "DSW_98084_PORT_80_TCP=tcp://10.192.30.20:80\n",
      "NV_LIBNCCL_PACKAGE=libnccl2=2.17.1-1+cuda12.1\n",
      "NV_LIBCUSPARSE_DEV_VERSION=12.0.2.55-1\n",
      "NV_LIBNCCL_DEV_PACKAGE_NAME=libnccl-dev\n",
      "KUBERNETES_PORT_443_TCP_PROTO=tcp\n",
      "DSW_107274_PORT_80_TCP=tcp://10.192.12.78:80\n",
      "NVIDIA_PRODUCT_NAME=CUDA\n",
      "LANG=zh_CN.UTF-8\n",
      "DSW_98084_SERVICE_PORT_HTTP_DSW_98084=80\n",
      "DSW_96358_PORT_80_TCP=tcp://10.192.28.168:80\n",
      "DSW_96358_SERVICE_PORT_SSH_DSW_96358=22\n",
      "NV_CUDA_CUDART_DEV_VERSION=12.1.55-1\n",
      "PAI_TRAINING_USE_ECI=true\n",
      "DSW_95221_SERVICE_HOST=10.192.9.246\n",
      "DSW_107274_SERVICE_PORT_HTTP_DSW_107274=80\n",
      "NV_LIBCUBLAS_DEV_PACKAGE=libcublas-dev-12-1=12.1.0.26-1\n",
      "SHELL=/bin/bash\n",
      "NV_CUDA_NSIGHT_COMPUTE_DEV_PACKAGE=cuda-nsight-compute-12-1=12.1.0-1\n",
      "KUBERNETES_CONTAINER_RESOURCE_GPU=1\n",
      "DSW_96358_SERVICE_PORT_HTTP_DSW_96358=80\n",
      "NV_LIBNCCL_DEV_PACKAGE=libnccl-dev=2.17.1-1+cuda12.1\n",
      "SETUPTOOLS_USE_DISTUTILS=stdlib\n",
      "NV_NVTX_VERSION=12.1.66-1\n",
      "NV_LIBNPP_VERSION=12.0.2.50-1\n",
      "CONDA_DIR=/opt/conda\n",
      "KUBERNETES_SERVICE_PORT_HTTPS=443\n",
      "KUBERNETES_PORT_443_TCP=tcp://10.192.0.1:443\n",
      "NV_CUDNN_VERSION=8.9.0.131\n",
      "LC_ALL=zh_CN.UTF-8\n",
      "KUBERNETES_SERVICE_HOST=10.224.148.12\n",
      "DSW_95221_PORT=tcp://10.192.9.246:80\n",
      "DSW_95221_SERVICE_PORT=80\n",
      "PWD=/\n",
      "PAI_HPS_EPOCHS=2\n",
      "PAI_HPS={\"batch_size\":\"128\",\"epochs\":\"2\",\"initial_learning_rate\":\"0.0001\",\"num_classes\":\"14\"}\n",
      "MODELSCOPE_CACHE=/mnt/workspace/.cache/modelscope\n",
      "DSW_95221_PORT_22_TCP_ADDR=10.192.9.246\n",
      "PAI_HPS_BATCH_SIZE=128\n",
      "NVIDIA_VISIBLE_DEVICES=0\n",
      "NCCL_VERSION=2.17.1-1\n",
      "TZ=Asia/Shanghai\n",
      "DSW_98084_SERVICE_HOST=10.192.30.20\n",
      "NV_LIBNPP_DEV_VERSION=12.0.2.50-1\n",
      "DSW_107274_SERVICE_HOST=10.192.12.78\n",
      "DSW_96358_SERVICE_HOST=10.192.28.168\n",
      "DSW_95221_PORT_22_TCP_PORT=22\n",
      "PAI_ODPS_CREDENTIAL=/ml/input/credential/odps.json\n",
      "PAI_WORKING_DIR=/ml/usercode/\n",
      "Change to Working Directory, /ml/usercode/\n",
      "User program launching\n",
      "-----------------------------------------------------------------\n",
      "2024-02-20 18:15:18,387 - modelscope - INFO - PyTorch version 2.1.2+cu121 Found.\n",
      "2024-02-20 18:15:18,629 - modelscope - INFO - TensorFlow version 2.14.0 Found.\n",
      "2024-02-20 18:15:18,629 - modelscope - INFO - Loading ast index from /mnt/workspace/.cache/modelscope/ast_indexer\n",
      "2024-02-20 18:15:18,884 - modelscope - INFO - Updating the files for the changes of local files, first time updating will take longer time! Please wait till updating done!\n",
      "2024-02-20 18:15:18,893 - modelscope - INFO - AST-Scanning the path \"/opt/conda/lib/python3.10/site-packages/modelscope\" with the following sub folders ['models', 'metrics', 'pipelines', 'preprocessors', 'trainers', 'msdatasets', 'exporters']\n",
      "2024-02-20 18:15:30,563 - modelscope - INFO - Scanning done! A number of 953 components indexed or updated! Time consumed 11.669828414916992s\n",
      "2024-02-20 18:15:30,589 - modelscope - INFO - Loading done! Current index file version is 1.11.0, with md5 78ae0053061258deadeb085b5bb62332 and a total number of 953 components indexed\n",
      "2024-02-20 18:15:46,153 - modelscope - WARNING - Reusing dataset dataset_builder (/root/.cache/modelscope/hub/datasets/tany0699/flowers14/master/data_files)\n",
      "2024-02-20 18:15:46,153 - modelscope - INFO - Generating dataset dataset_builder (/root/.cache/modelscope/hub/datasets/tany0699/flowers14/master/data_files)\n",
      "2024-02-20 18:15:46,153 - modelscope - INFO - Loading meta-data file ...\n",
      "13643it [00:00, 19419.97it/s]\n",
      "2024-02-20 18:15:54,666 - modelscope - WARNING - Reusing dataset dataset_builder (/root/.cache/modelscope/hub/datasets/tany0699/flowers14/master/data_files)\n",
      "2024-02-20 18:15:54,666 - modelscope - INFO - Generating dataset dataset_builder (/root/.cache/modelscope/hub/datasets/tany0699/flowers14/master/data_files)\n",
      "2024-02-20 18:15:54,666 - modelscope - INFO - Loading meta-data file ...\n",
      "  2%|▏         | 99/4410 [00:00<00:00, 397355.12it/s]\n",
      "2024-02-20 18:15:56,550 - modelscope - WARNING - Model revision not specified, use revision: v1.0.2\n",
      "Downloading: 100%|██████████| 9.31k/9.31k [00:00<00:00, 71.1MB/s]\n",
      "2024-02-20 18:15:58,016 - modelscope - WARNING - Model revision not specified, use revision: v1.0.2\n",
      "Downloading: 0.00B [00:00, ?B/s]\n",
      "Downloading: 100%|██████████| 12.5k/12.5k [00:00<00:00, 97.4MB/s]\n",
      "Downloading: 100%|██████████| 330M/330M [00:01<00:00, 192MB/s] \n",
      "Downloading: 100%|██████████| 2.97k/2.97k [00:00<00:00, 34.8MB/s]\n",
      "Downloading: 100%|██████████| 68.2k/68.2k [00:00<00:00, 36.7MB/s]\n",
      "/opt/conda/lib/python3.10/site-packages/mmcv/__init__.py:20: UserWarning: On January 1, 2023, MMCV will release v2.0.0, in which it will remove components related to the training process and add a data transformation module. In addition, it will rename the package names mmcv to mmcv-lite and mmcv-full to mmcv. See https://github.com/open-mmlab/mmcv/blob/master/docs/en/compatibility.md for more details.\n",
      "  warnings.warn(\n",
      "2024-02-20 18:16:18,725 - modelscope - WARNING - Model revision not specified, use revision: v1.0.2\n",
      "fatal: not a git repository (or any parent up to mount point /ml)\n",
      "Stopping at filesystem boundary (GIT_DISCOVERY_ACROSS_FILESYSTEM not set).\n",
      "2024-02-20 18:16:29,703 - modelscope - INFO - Environment info:\n",
      "------------------------------------------------------------\n",
      "sys.platform: linux\n",
      "Python: 3.10.13 (main, Sep 11 2023, 13:44:35) [GCC 11.2.0]\n",
      "CUDA available: True\n",
      "GPU 0: NVIDIA A100-SXM4-80GB\n",
      "CUDA_HOME: /usr/local/cuda\n",
      "NVCC: Cuda compilation tools, release 12.1, V12.1.105\n",
      "GCC: gcc (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0\n",
      "PyTorch: 2.1.2+cu121\n",
      "PyTorch compiling details: PyTorch built with:\n",
      "  - GCC 9.3\n",
      "  - C++ Version: 201703\n",
      "  - Intel(R) oneAPI Math Kernel Library Version 2022.2-Product Build 20220804 for Intel(R) 64 architecture applications\n",
      "  - Intel(R) MKL-DNN v3.1.1 (Git Hash 64f6bcbcbab628e96f33a62c3e975f8535a7bde4)\n",
      "  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n",
      "  - LAPACK is enabled (usually provided by MKL)\n",
      "  - NNPACK is enabled\n",
      "  - CPU capability usage: AVX512\n",
      "  - CUDA Runtime 12.1\n",
      "  - NVCC architecture flags: -gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90\n",
      "  - CuDNN 8.9.2\n",
      "  - Magma 2.6.1\n",
      "  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, CUDA_VERSION=12.1, CUDNN_VERSION=8.9.2, CXX_COMPILER=/opt/rh/devtoolset-9/root/usr/bin/c++, CXX_FLAGS= -D_GLIBCXX_USE_CXX11_ABI=0 -fabi-version=11 -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-unused-parameter -Wno-unused-function -Wno-unused-result -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=old-style-cast -Wno-invalid-partial-specialization -Wno-unused-private-field -Wno-aligned-allocation-unavailable -Wno-missing-braces -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Werror=cast-function-type -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, TORCH_DISABLE_GPU_ASSERTS=ON, TORCH_VERSION=2.1.2, USE_CUDA=ON, USE_CUDNN=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, \n",
      "\n",
      "TorchVision: 0.16.2+cu121\n",
      "OpenCV: 4.9.0\n",
      "MMCV: 1.7.0\n",
      "MMCV Compiler: GCC 11.4\n",
      "MMCV CUDA Compiler: 12.1\n",
      "MMClassification: 0.25.0+\n",
      "------------------------------------------------------------\n",
      "\n",
      "2024-02-20 18:16:29,703 - modelscope - INFO - Environment info:\n",
      "------------------------------------------------------------\n",
      "sys.platform: linux\n",
      "Python: 3.10.13 (main, Sep 11 2023, 13:44:35) [GCC 11.2.0]\n",
      "CUDA available: True\n",
      "GPU 0: NVIDIA A100-SXM4-80GB\n",
      "CUDA_HOME: /usr/local/cuda\n",
      "NVCC: Cuda compilation tools, release 12.1, V12.1.105\n",
      "GCC: gcc (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0\n",
      "PyTorch: 2.1.2+cu121\n",
      "PyTorch compiling details: PyTorch built with:\n",
      "  - GCC 9.3\n",
      "  - C++ Version: 201703\n",
      "  - Intel(R) oneAPI Math Kernel Library Version 2022.2-Product Build 20220804 for Intel(R) 64 architecture applications\n",
      "  - Intel(R) MKL-DNN v3.1.1 (Git Hash 64f6bcbcbab628e96f33a62c3e975f8535a7bde4)\n",
      "  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n",
      "  - LAPACK is enabled (usually provided by MKL)\n",
      "  - NNPACK is enabled\n",
      "  - CPU capability usage: AVX512\n",
      "  - CUDA Runtime 12.1\n",
      "  - NVCC architecture flags: -gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90\n",
      "  - CuDNN 8.9.2\n",
      "  - Magma 2.6.1\n",
      "  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, CUDA_VERSION=12.1, CUDNN_VERSION=8.9.2, CXX_COMPILER=/opt/rh/devtoolset-9/root/usr/bin/c++, CXX_FLAGS= -D_GLIBCXX_USE_CXX11_ABI=0 -fabi-version=11 -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-unused-parameter -Wno-unused-function -Wno-unused-result -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=old-style-cast -Wno-invalid-partial-specialization -Wno-unused-private-field -Wno-aligned-allocation-unavailable -Wno-missing-braces -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Werror=cast-function-type -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, TORCH_DISABLE_GPU_ASSERTS=ON, TORCH_VERSION=2.1.2, USE_CUDA=ON, USE_CUDNN=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, \n",
      "\n",
      "TorchVision: 0.16.2+cu121\n",
      "OpenCV: 4.9.0\n",
      "MMCV: 1.7.0\n",
      "MMCV Compiler: GCC 11.4\n",
      "MMCV CUDA Compiler: 12.1\n",
      "MMClassification: 0.25.0+\n",
      "------------------------------------------------------------\n",
      "\n",
      "2024-02-20 18:16:30,223 - modelscope - INFO - Distributed training: False\n",
      "2024-02-20 18:16:30,223 - modelscope - INFO - Distributed training: False\n",
      "2024-02-20 18:16:30,734 - modelscope - INFO - Config:\n",
      "framework = 'pytorch'\n",
      "task = 'image-classification'\n",
      "pipeline = dict(type='vit-base_image-classification_ImageNet-labels')\n",
      "model = dict(\n",
      "    type='ClassificationModel',\n",
      "    mm_model=dict(\n",
      "        type='ImageClassifier',\n",
      "        pretrained=None,\n",
      "        backbone=dict(\n",
      "            type='VisionTransformer',\n",
      "            arch='deit-base',\n",
      "            img_size=224,\n",
      "            patch_size=16,\n",
      "            drop_path_rate=0.1),\n",
      "        neck=None,\n",
      "        head=dict(\n",
      "            type='VisionTransformerClsHead',\n",
      "            num_classes=14,\n",
      "            in_channels=768,\n",
      "            loss=dict(\n",
      "                type='LabelSmoothLoss', label_smooth_val=0.1,\n",
      "                mode='original')),\n",
      "        init_cfg=[\n",
      "            dict(type='TruncNormal', layer='Linear', std=0.02),\n",
      "            dict(type='Constant', layer='LayerNorm', val=1.0, bias=0.0)\n",
      "        ],\n",
      "        train_cfg=dict(augments=[\n",
      "            dict(type='BatchMixup', alpha=0.8, num_classes=14, prob=0.5),\n",
      "            dict(type='BatchCutMix', alpha=1.0, num_classes=14, prob=0.5)\n",
      "        ])))\n",
      "dataset = dict(classes=None)\n",
      "preprocessor = dict(\n",
      "    type='image-classification-bypass-preprocessor',\n",
      "    train=[\n",
      "        dict(type='LoadImageFromFile'),\n",
      "        dict(\n",
      "            type='RandomResizedCrop',\n",
      "            size=224,\n",
      "            backend='pillow',\n",
      "            interpolation='bicubic'),\n",
      "        dict(type='RandomFlip', flip_prob=0.5, direction='horizontal'),\n",
      "        dict(\n",
      "            type='RandAugment',\n",
      "            policies=[\n",
      "                dict(type='AutoContrast'),\n",
      "                dict(type='Equalize'),\n",
      "                dict(type='Invert'),\n",
      "                dict(\n",
      "                    type='Rotate',\n",
      "                    magnitude_key='angle',\n",
      "                    magnitude_range=[0, 30]),\n",
      "                dict(\n",
      "                    type='Posterize',\n",
      "                    magnitude_key='bits',\n",
      "                    magnitude_range=[4, 0]),\n",
      "                dict(\n",
      "                    type='Solarize',\n",
      "                    magnitude_key='thr',\n",
      "                    magnitude_range=[256, 0]),\n",
      "                dict(\n",
      "                    type='SolarizeAdd',\n",
      "                    magnitude_key='magnitude',\n",
      "                    magnitude_range=[0, 110]),\n",
      "                dict(\n",
      "                    type='ColorTransform',\n",
      "                    magnitude_key='magnitude',\n",
      "                    magnitude_range=[0, 0.9]),\n",
      "                dict(\n",
      "                    type='Contrast',\n",
      "                    magnitude_key='magnitude',\n",
      "                    magnitude_range=[0, 0.9]),\n",
      "                dict(\n",
      "                    type='Brightness',\n",
      "                    magnitude_key='magnitude',\n",
      "                    magnitude_range=[0, 0.9]),\n",
      "                dict(\n",
      "                    type='Sharpness',\n",
      "                    magnitude_key='magnitude',\n",
      "                    magnitude_range=[0, 0.9]),\n",
      "                dict(\n",
      "                    type='Shear',\n",
      "                    magnitude_key='magnitude',\n",
      "                    magnitude_range=[0, 0.3],\n",
      "                    direction='horizontal'),\n",
      "                dict(\n",
      "                    type='Shear',\n",
      "                    magnitude_key='magnitude',\n",
      "                    magnitude_range=[0, 0.3],\n",
      "                    direction='vertical'),\n",
      "                dict(\n",
      "                    type='Translate',\n",
      "                    magnitude_key='magnitude',\n",
      "                    magnitude_range=[0, 0.45],\n",
      "                    direction='horizontal'),\n",
      "                dict(\n",
      "                    type='Translate',\n",
      "                    magnitude_key='magnitude',\n",
      "                    magnitude_range=[0, 0.45],\n",
      "                    direction='vertical')\n",
      "            ],\n",
      "            num_policies=2,\n",
      "            total_level=10,\n",
      "            magnitude_level=9,\n",
      "            magnitude_std=0.5,\n",
      "            hparams=dict(pad_val=[104, 116, 124], interpolation='bicubic')),\n",
      "        dict(\n",
      "            type='RandomErasing',\n",
      "            erase_prob=0.25,\n",
      "            mode='rand',\n",
      "            min_area_ratio=0.02,\n",
      "            max_area_ratio=0.3333333333333333,\n",
      "            fill_color=[103.53, 116.28, 123.675],\n",
      "            fill_std=[57.375, 57.12, 58.395]),\n",
      "        dict(\n",
      "            type='Normalize',\n",
      "            mean=[123.675, 116.28, 103.53],\n",
      "            std=[58.395, 57.12, 57.375],\n",
      "            to_rgb=True),\n",
      "        dict(type='ImageToTensor', keys=['img']),\n",
      "        dict(type='ToTensor', keys=['gt_label']),\n",
      "        dict(type='Collect', keys=['img', 'gt_label'])\n",
      "    ],\n",
      "    val=[\n",
      "        dict(type='LoadImageFromFile'),\n",
      "        dict(\n",
      "            type='Resize',\n",
      "            size=[256, -1],\n",
      "            backend='pillow',\n",
      "            interpolation='bicubic'),\n",
      "        dict(type='CenterCrop', crop_size=224),\n",
      "        dict(\n",
      "            type='Normalize',\n",
      "            mean=[123.675, 116.28, 103.53],\n",
      "            std=[58.395, 57.12, 57.375],\n",
      "            to_rgb=True),\n",
      "        dict(type='ImageToTensor', keys=['img']),\n",
      "        dict(type='Collect', keys=['img'])\n",
      "    ])\n",
      "train = dict(\n",
      "    dataloader=dict(batch_size_per_gpu=128, workers_per_gpu=8),\n",
      "    max_epochs=1,\n",
      "    runner=dict(type='EpochBasedRunner', max_epochs=1),\n",
      "    evaluation=dict(interval=1, metric='accuracy', save_best='auto'),\n",
      "    checkpoint_config=dict(\n",
      "        interval=1, max_keep_ckpts=20, create_symlink=False),\n",
      "    log_config=dict(interval=100, hooks=[dict(type='TextLoggerHook')]),\n",
      "    custom_hooks=[\n",
      "        dict(type='EMAHook', momentum=4e-05, priority='ABOVE_NORMAL')\n",
      "    ],\n",
      "    workflow=[['train', 1]],\n",
      "    work_dir='./work_dir',\n",
      "    optimizer=dict(\n",
      "        type='AdamW',\n",
      "        lr=0.0001,\n",
      "        weight_decay=0.1,\n",
      "        eps=1e-08,\n",
      "        betas=[0.9, 0.999],\n",
      "        paramwise_cfg=dict(\n",
      "            norm_decay_mult=0.0,\n",
      "            bias_decay_mult=0.0,\n",
      "            custom_keys=dict({\n",
      "                '.absolute_pos_embed':\n",
      "                dict(decay_mult=0.0),\n",
      "                '.relative_position_bias_table':\n",
      "                dict(decay_mult=0.0),\n",
      "                '.cls_token':\n",
      "                dict(decay_mult=0.0),\n",
      "                '.pos_embed':\n",
      "                dict(decay_mult=0.0)\n",
      "            }))),\n",
      "    optimizer_config=dict(grad_clip=dict(max_norm=5.0)),\n",
      "    lr_config=dict(\n",
      "        policy='CosineAnnealing',\n",
      "        by_epoch=False,\n",
      "        min_lr_ratio=0.01,\n",
      "        warmup='linear',\n",
      "        warmup_ratio=0.001,\n",
      "        warmup_iters=1,\n",
      "        warmup_by_epoch=True),\n",
      "    resume_from=None,\n",
      "    load_from=\n",
      "    '/mnt/workspace/.cache/modelscope/damo/cv_vit-base_image-classification_ImageNet-labels/pytorch_model.pt'\n",
      ")\n",
      "evaluation = dict(\n",
      "    dataloader=dict(batch_size_per_gpu=32, workers_per_gpu=4),\n",
      "    metrics=['accuracy'])\n",
      "work_dir = '/ml/output/checkpoints/'\n",
      "device = 'cuda'\n",
      "gpu_ids = [0]\n",
      "fp16 = None\n",
      "no_validate = False\n",
      "\n",
      "2024-02-20 18:16:30,734 - modelscope - INFO - Config:\n",
      "framework = 'pytorch'\n",
      "task = 'image-classification'\n",
      "pipeline = dict(type='vit-base_image-classification_ImageNet-labels')\n",
      "model = dict(\n",
      "    type='ClassificationModel',\n",
      "    mm_model=dict(\n",
      "        type='ImageClassifier',\n",
      "        pretrained=None,\n",
      "        backbone=dict(\n",
      "            type='VisionTransformer',\n",
      "            arch='deit-base',\n",
      "            img_size=224,\n",
      "            patch_size=16,\n",
      "            drop_path_rate=0.1),\n",
      "        neck=None,\n",
      "        head=dict(\n",
      "            type='VisionTransformerClsHead',\n",
      "            num_classes=14,\n",
      "            in_channels=768,\n",
      "            loss=dict(\n",
      "                type='LabelSmoothLoss', label_smooth_val=0.1,\n",
      "                mode='original')),\n",
      "        init_cfg=[\n",
      "            dict(type='TruncNormal', layer='Linear', std=0.02),\n",
      "            dict(type='Constant', layer='LayerNorm', val=1.0, bias=0.0)\n",
      "        ],\n",
      "        train_cfg=dict(augments=[\n",
      "            dict(type='BatchMixup', alpha=0.8, num_classes=14, prob=0.5),\n",
      "            dict(type='BatchCutMix', alpha=1.0, num_classes=14, prob=0.5)\n",
      "        ])))\n",
      "dataset = dict(classes=None)\n",
      "preprocessor = dict(\n",
      "    type='image-classification-bypass-preprocessor',\n",
      "    train=[\n",
      "        dict(type='LoadImageFromFile'),\n",
      "        dict(\n",
      "            type='RandomResizedCrop',\n",
      "            size=224,\n",
      "            backend='pillow',\n",
      "            interpolation='bicubic'),\n",
      "        dict(type='RandomFlip', flip_prob=0.5, direction='horizontal'),\n",
      "        dict(\n",
      "            type='RandAugment',\n",
      "            policies=[\n",
      "                dict(type='AutoContrast'),\n",
      "                dict(type='Equalize'),\n",
      "                dict(type='Invert'),\n",
      "                dict(\n",
      "                    type='Rotate',\n",
      "                    magnitude_key='angle',\n",
      "                    magnitude_range=[0, 30]),\n",
      "                dict(\n",
      "                    type='Posterize',\n",
      "                    magnitude_key='bits',\n",
      "                    magnitude_range=[4, 0]),\n",
      "                dict(\n",
      "                    type='Solarize',\n",
      "                    magnitude_key='thr',\n",
      "                    magnitude_range=[256, 0]),\n",
      "                dict(\n",
      "                    type='SolarizeAdd',\n",
      "                    magnitude_key='magnitude',\n",
      "                    magnitude_range=[0, 110]),\n",
      "                dict(\n",
      "                    type='ColorTransform',\n",
      "                    magnitude_key='magnitude',\n",
      "                    magnitude_range=[0, 0.9]),\n",
      "                dict(\n",
      "                    type='Contrast',\n",
      "                    magnitude_key='magnitude',\n",
      "                    magnitude_range=[0, 0.9]),\n",
      "                dict(\n",
      "                    type='Brightness',\n",
      "                    magnitude_key='magnitude',\n",
      "                    magnitude_range=[0, 0.9]),\n",
      "                dict(\n",
      "                    type='Sharpness',\n",
      "                    magnitude_key='magnitude',\n",
      "                    magnitude_range=[0, 0.9]),\n",
      "                dict(\n",
      "                    type='Shear',\n",
      "                    magnitude_key='magnitude',\n",
      "                    magnitude_range=[0, 0.3],\n",
      "                    direction='horizontal'),\n",
      "                dict(\n",
      "                    type='Shear',\n",
      "                    magnitude_key='magnitude',\n",
      "                    magnitude_range=[0, 0.3],\n",
      "                    direction='vertical'),\n",
      "                dict(\n",
      "                    type='Translate',\n",
      "                    magnitude_key='magnitude',\n",
      "                    magnitude_range=[0, 0.45],\n",
      "                    direction='horizontal'),\n",
      "                dict(\n",
      "                    type='Translate',\n",
      "                    magnitude_key='magnitude',\n",
      "                    magnitude_range=[0, 0.45],\n",
      "                    direction='vertical')\n",
      "            ],\n",
      "            num_policies=2,\n",
      "            total_level=10,\n",
      "            magnitude_level=9,\n",
      "            magnitude_std=0.5,\n",
      "            hparams=dict(pad_val=[104, 116, 124], interpolation='bicubic')),\n",
      "        dict(\n",
      "            type='RandomErasing',\n",
      "            erase_prob=0.25,\n",
      "            mode='rand',\n",
      "            min_area_ratio=0.02,\n",
      "            max_area_ratio=0.3333333333333333,\n",
      "            fill_color=[103.53, 116.28, 123.675],\n",
      "            fill_std=[57.375, 57.12, 58.395]),\n",
      "        dict(\n",
      "            type='Normalize',\n",
      "            mean=[123.675, 116.28, 103.53],\n",
      "            std=[58.395, 57.12, 57.375],\n",
      "            to_rgb=True),\n",
      "        dict(type='ImageToTensor', keys=['img']),\n",
      "        dict(type='ToTensor', keys=['gt_label']),\n",
      "        dict(type='Collect', keys=['img', 'gt_label'])\n",
      "    ],\n",
      "    val=[\n",
      "        dict(type='LoadImageFromFile'),\n",
      "        dict(\n",
      "            type='Resize',\n",
      "            size=[256, -1],\n",
      "            backend='pillow',\n",
      "            interpolation='bicubic'),\n",
      "        dict(type='CenterCrop', crop_size=224),\n",
      "        dict(\n",
      "            type='Normalize',\n",
      "            mean=[123.675, 116.28, 103.53],\n",
      "            std=[58.395, 57.12, 57.375],\n",
      "            to_rgb=True),\n",
      "        dict(type='ImageToTensor', keys=['img']),\n",
      "        dict(type='Collect', keys=['img'])\n",
      "    ])\n",
      "train = dict(\n",
      "    dataloader=dict(batch_size_per_gpu=128, workers_per_gpu=8),\n",
      "    max_epochs=1,\n",
      "    runner=dict(type='EpochBasedRunner', max_epochs=1),\n",
      "    evaluation=dict(interval=1, metric='accuracy', save_best='auto'),\n",
      "    checkpoint_config=dict(\n",
      "        interval=1, max_keep_ckpts=20, create_symlink=False),\n",
      "    log_config=dict(interval=100, hooks=[dict(type='TextLoggerHook')]),\n",
      "    custom_hooks=[\n",
      "        dict(type='EMAHook', momentum=4e-05, priority='ABOVE_NORMAL')\n",
      "    ],\n",
      "    workflow=[['train', 1]],\n",
      "    work_dir='./work_dir',\n",
      "    optimizer=dict(\n",
      "        type='AdamW',\n",
      "        lr=0.0001,\n",
      "        weight_decay=0.1,\n",
      "        eps=1e-08,\n",
      "        betas=[0.9, 0.999],\n",
      "        paramwise_cfg=dict(\n",
      "            norm_decay_mult=0.0,\n",
      "            bias_decay_mult=0.0,\n",
      "            custom_keys=dict({\n",
      "                '.absolute_pos_embed':\n",
      "                dict(decay_mult=0.0),\n",
      "                '.relative_position_bias_table':\n",
      "                dict(decay_mult=0.0),\n",
      "                '.cls_token':\n",
      "                dict(decay_mult=0.0),\n",
      "                '.pos_embed':\n",
      "                dict(decay_mult=0.0)\n",
      "            }))),\n",
      "    optimizer_config=dict(grad_clip=dict(max_norm=5.0)),\n",
      "    lr_config=dict(\n",
      "        policy='CosineAnnealing',\n",
      "        by_epoch=False,\n",
      "        min_lr_ratio=0.01,\n",
      "        warmup='linear',\n",
      "        warmup_ratio=0.001,\n",
      "        warmup_iters=1,\n",
      "        warmup_by_epoch=True),\n",
      "    resume_from=None,\n",
      "    load_from=\n",
      "    '/mnt/workspace/.cache/modelscope/damo/cv_vit-base_image-classification_ImageNet-labels/pytorch_model.pt'\n",
      ")\n",
      "evaluation = dict(\n",
      "    dataloader=dict(batch_size_per_gpu=32, workers_per_gpu=4),\n",
      "    metrics=['accuracy'])\n",
      "work_dir = '/ml/output/checkpoints/'\n",
      "device = 'cuda'\n",
      "gpu_ids = [0]\n",
      "fp16 = None\n",
      "no_validate = False\n",
      "\n",
      "2024-02-20 18:16:30,734 - modelscope - INFO - Set random seed to 0, deterministic: False\n",
      "2024-02-20 18:16:30,734 - modelscope - INFO - Set random seed to 0, deterministic: False\n",
      "2024-02-20 18:16:31,253 - modelscope - INFO - initialize ImageClassifier with init_cfg [{'type': 'TruncNormal', 'layer': 'Linear', 'std': 0.02}, {'type': 'Constant', 'layer': 'LayerNorm', 'val': 1.0, 'bias': 0.0}]\n",
      "2024-02-20 18:16:31,253 - modelscope - INFO - initialize ImageClassifier with init_cfg [{'type': 'TruncNormal', 'layer': 'Linear', 'std': 0.02}, {'type': 'Constant', 'layer': 'LayerNorm', 'val': 1.0, 'bias': 0.0}]\n",
      "2024-02-20 18:16:31,980 - modelscope - INFO - initialize VisionTransformerClsHead with init_cfg {'type': 'Constant', 'layer': 'Linear', 'val': 0}\n",
      "2024-02-20 18:16:31,980 - modelscope - INFO - initialize VisionTransformerClsHead with init_cfg {'type': 'Constant', 'layer': 'Linear', 'val': 0}\n",
      "2024-02-20 18:16:33,984 - modelscope - INFO - load checkpoint from local path: /mnt/workspace/.cache/modelscope/damo/cv_vit-base_image-classification_ImageNet-labels/pytorch_model.pt\n",
      "2024-02-20 18:16:33,984 - modelscope - INFO - load checkpoint from local path: /mnt/workspace/.cache/modelscope/damo/cv_vit-base_image-classification_ImageNet-labels/pytorch_model.pt\n",
      "2024-02-20 18:16:34,143 - modelscope - WARNING - The model and loaded state dict do not match exactly\n",
      "\n",
      "size mismatch for head.layers.head.weight: copying a param with shape torch.Size([1000, 768]) from checkpoint, the shape in current model is torch.Size([14, 768]).\n",
      "size mismatch for head.layers.head.bias: copying a param with shape torch.Size([1000]) from checkpoint, the shape in current model is torch.Size([14]).\n",
      "2024-02-20 18:16:34,143 - modelscope - WARNING - The model and loaded state dict do not match exactly\n",
      "\n",
      "size mismatch for head.layers.head.weight: copying a param with shape torch.Size([1000, 768]) from checkpoint, the shape in current model is torch.Size([14, 768]).\n",
      "size mismatch for head.layers.head.bias: copying a param with shape torch.Size([1000]) from checkpoint, the shape in current model is torch.Size([14]).\n",
      "2024-02-20 18:16:34,148 - modelscope - INFO - Start running, host: root@train137j6rqoh43-master-0, work_dir: /ml/output/checkpoints\n",
      "2024-02-20 18:16:34,148 - modelscope - INFO - Start running, host: root@train137j6rqoh43-master-0, work_dir: /ml/output/checkpoints\n",
      "2024-02-20 18:16:34,148 - modelscope - INFO - Hooks will be executed in the following order:\n",
      "before_run:\n",
      "(VERY_HIGH   ) CosineAnnealingLrUpdaterHook       \n",
      "(ABOVE_NORMAL) EMAHook                            \n",
      "(NORMAL      ) CheckpointHook                     \n",
      "(LOW         ) EvalHook                           \n",
      "(VERY_LOW    ) TextLoggerHook                     \n",
      " -------------------- \n",
      "before_train_epoch:\n",
      "(VERY_HIGH   ) CosineAnnealingLrUpdaterHook       \n",
      "(ABOVE_NORMAL) EMAHook                            \n",
      "(LOW         ) IterTimerHook                      \n",
      "(LOW         ) EvalHook                           \n",
      "(VERY_LOW    ) TextLoggerHook                     \n",
      " -------------------- \n",
      "before_train_iter:\n",
      "(VERY_HIGH   ) CosineAnnealingLrUpdaterHook       \n",
      "(LOW         ) IterTimerHook                      \n",
      "(LOW         ) EvalHook                           \n",
      " -------------------- \n",
      "after_train_iter:\n",
      "(ABOVE_NORMAL) OptimizerHook                      \n",
      "(ABOVE_NORMAL) EMAHook                            \n",
      "(NORMAL      ) CheckpointHook                     \n",
      "(LOW         ) IterTimerHook                      \n",
      "(LOW         ) EvalHook                           \n",
      "(VERY_LOW    ) TextLoggerHook                     \n",
      " -------------------- \n",
      "after_train_epoch:\n",
      "(ABOVE_NORMAL) EMAHook                            \n",
      "(NORMAL      ) CheckpointHook                     \n",
      "(LOW         ) EvalHook                           \n",
      "(VERY_LOW    ) TextLoggerHook                     \n",
      " -------------------- \n",
      "before_val_epoch:\n",
      "(LOW         ) IterTimerHook                      \n",
      "(VERY_LOW    ) TextLoggerHook                     \n",
      " -------------------- \n",
      "before_val_iter:\n",
      "(LOW         ) IterTimerHook                      \n",
      " -------------------- \n",
      "after_val_iter:\n",
      "(LOW         ) IterTimerHook                      \n",
      " -------------------- \n",
      "after_val_epoch:\n",
      "(VERY_LOW    ) TextLoggerHook                     \n",
      " -------------------- \n",
      "after_run:\n",
      "(VERY_LOW    ) TextLoggerHook                     \n",
      " -------------------- \n",
      "2024-02-20 18:16:34,148 - modelscope - INFO - Hooks will be executed in the following order:\n",
      "before_run:\n",
      "(VERY_HIGH   ) CosineAnnealingLrUpdaterHook       \n",
      "(ABOVE_NORMAL) EMAHook                            \n",
      "(NORMAL      ) CheckpointHook                     \n",
      "(LOW         ) EvalHook                           \n",
      "(VERY_LOW    ) TextLoggerHook                     \n",
      " -------------------- \n",
      "before_train_epoch:\n",
      "(VERY_HIGH   ) CosineAnnealingLrUpdaterHook       \n",
      "(ABOVE_NORMAL) EMAHook                            \n",
      "(LOW         ) IterTimerHook                      \n",
      "(LOW         ) EvalHook                           \n",
      "(VERY_LOW    ) TextLoggerHook                     \n",
      " -------------------- \n",
      "before_train_iter:\n",
      "(VERY_HIGH   ) CosineAnnealingLrUpdaterHook       \n",
      "(LOW         ) IterTimerHook                      \n",
      "(LOW         ) EvalHook                           \n",
      " -------------------- \n",
      "after_train_iter:\n",
      "(ABOVE_NORMAL) OptimizerHook                      \n",
      "(ABOVE_NORMAL) EMAHook                            \n",
      "(NORMAL      ) CheckpointHook                     \n",
      "(LOW         ) IterTimerHook                      \n",
      "(LOW         ) EvalHook                           \n",
      "(VERY_LOW    ) TextLoggerHook                     \n",
      " -------------------- \n",
      "after_train_epoch:\n",
      "(ABOVE_NORMAL) EMAHook                            \n",
      "(NORMAL      ) CheckpointHook                     \n",
      "(LOW         ) EvalHook                           \n",
      "(VERY_LOW    ) TextLoggerHook                     \n",
      " -------------------- \n",
      "before_val_epoch:\n",
      "(LOW         ) IterTimerHook                      \n",
      "(VERY_LOW    ) TextLoggerHook                     \n",
      " -------------------- \n",
      "before_val_iter:\n",
      "(LOW         ) IterTimerHook                      \n",
      " -------------------- \n",
      "after_val_iter:\n",
      "(LOW         ) IterTimerHook                      \n",
      " -------------------- \n",
      "after_val_epoch:\n",
      "(VERY_LOW    ) TextLoggerHook                     \n",
      " -------------------- \n",
      "after_run:\n",
      "(VERY_LOW    ) TextLoggerHook                     \n",
      " -------------------- \n",
      "2024-02-20 18:16:34,148 - modelscope - INFO - workflow: [('train', 1)], max: 1 epochs\n",
      "2024-02-20 18:16:34,148 - modelscope - INFO - workflow: [('train', 1)], max: 1 epochs\n",
      "2024-02-20 18:16:34,153 - modelscope - INFO - Checkpoints will be saved to /ml/output/checkpoints by HardDiskBackend.\n",
      "2024-02-20 18:16:34,153 - modelscope - INFO - Checkpoints will be saved to /ml/output/checkpoints by HardDiskBackend.\n",
      "/opt/conda/lib/python3.10/site-packages/mmcv/runner/hooks/ema.py:73: UserWarning: This overload of add_ is deprecated:\n",
      "\tadd_(Number alpha, Tensor other)\n",
      "Consider using one of the following signatures instead:\n",
      "\tadd_(Tensor other, *, Number alpha) (Triggered internally at ../torch/csrc/utils/python_arg_parser.cpp:1519.)\n",
      "  buffer_parameter.mul_(1 - momentum).add_(momentum, parameter.data)\n",
      "2024-02-20 18:18:11,946 - modelscope - INFO - Epoch [1][100/107]\tlr: 2.183e-06, eta: 0:00:06, time: 0.977, data_time: 0.040, memory: 18966, loss: 2.3911, grad_norm: 3.7871\n",
      "2024-02-20 18:18:11,946 - modelscope - INFO - Epoch [1][100/107]\tlr: 2.183e-06, eta: 0:00:06, time: 0.977, data_time: 0.040, memory: 18966, loss: 2.3911, grad_norm: 3.7871\n",
      "2024-02-20 18:18:17,842 - modelscope - INFO - Saving checkpoint at 1 epochs\n",
      "2024-02-20 18:18:17,842 - modelscope - INFO - Saving checkpoint at 1 epochs\n",
      "2024-02-20 18:18:34,049 - modelscope - INFO - Now best checkpoint is saved as best_accuracy_top-1_epoch_1.pth.\n",
      "2024-02-20 18:18:34,049 - modelscope - INFO - Now best checkpoint is saved as best_accuracy_top-1_epoch_1.pth.\n",
      "2024-02-20 18:18:34,050 - modelscope - INFO - Best accuracy_top-1 is 69.3878 at 1 epoch.\n",
      "2024-02-20 18:18:34,050 - modelscope - INFO - Best accuracy_top-1 is 69.3878 at 1 epoch.\n",
      "2024-02-20 18:18:34,050 - modelscope - INFO - Exp name: configuration.json\n",
      "2024-02-20 18:18:34,050 - modelscope - INFO - Exp name: configuration.json\n",
      "2024-02-20 18:18:34,050 - modelscope - INFO - Epoch(val) [1][4]\taccuracy_top-1: 69.3878, accuracy_top-5: 96.9388\n",
      "2024-02-20 18:18:34,050 - modelscope - INFO - Epoch(val) [1][4]\taccuracy_top-1: 69.3878, accuracy_top-5: 96.9388\n",
      "[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 98/98, 215.0 task/s, elapsed: 0s, ETA:     0sload checkpoint from local path: /ml/output/checkpoints/best_accuracy_top-1_epoch_1.pth\n",
      "[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 98/98, 207.2 task/s, elapsed: 0s, ETA:     0sEvaluation Result: {'accuracy_top-1': 69.38775634765625, 'accuracy_top-5': 96.93877410888672}\n",
      "Saving best checkpoint as pytorch_model.pt\n",
      "List work dir:  ['20240220_181618.log.json', 'best_accuracy_top-1_epoch_1.pth', 'configuration.json', 'epoch_1.pth']\n",
      "Found best checkpoint:  best_accuracy_top-1_epoch_1.pth\n",
      "\n",
      "Training job (train137j6rqoh43) succeeded, you can check the logs/metrics/output in  the console:\n",
      "https://pai.console.aliyun.com/?regionId=cn-hangzhou&workspaceId=58670#/training/jobs/train137j6rqoh43\n"
     ]
    }
   ],
   "source": [
    "est.fit()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "训练作业执行成功之后，用户可以通过`estimator.model_data()`获取相应产出模型的OSS路径"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 部署推理服务\n",
    "\n",
    "PAI-EAS是PAI提供的推理服务部署平台，支持使用Processor或是镜像的方式部署推理服务。在以下的流程中，我们将使用微调获得的模型，使用镜像部署的方式部署一个在线推理服务。\n",
    "\n",
    "### 准备推理服务使用的代码\n",
    "\n",
    "镜像部署的模式，要求用户提供一个推理服务程序，他负责加载模型，提供HTTP API，以支持接受用户推理请求，调用模型处理推理请求，返回推理结果。在当前示例中，我们将使用[FastAPI](https://fastapi.tiangolo.com/)编写一个推理服务程序，加载以上训练作业输出的模型，在PAI创建一个推理服务。\n",
    "\n",
    "我们首先创建一个目录(`serve_src`)，用于保存的推理服务程序代码。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "!mkdir -p serve_src/"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们准备的推理服务程序，支持用户通过HTTP POST发送的图片，然后调用ModelScope的推理pipeline获取预测结果，返回给到用户。\n",
    "\n",
    "> ModelScope 推理pipeline返回的结果中带有`numpy.ndarray`数据，需要我们通过自定义Encoder将其序列化。\n",
    "\n",
    "完整代码如下，我们将其保存到`serve_src`目录下，用于后续创建推理服务。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting serve_src/run.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile serve_src/run.py\n",
    "\n",
    "import os\n",
    "import io\n",
    "import json\n",
    "\n",
    "import uvicorn\n",
    "from fastapi import FastAPI, Response, Request\n",
    "import numpy as np\n",
    "\n",
    "from modelscope.pipelines import pipeline\n",
    "from modelscope.utils.constant import Tasks\n",
    "from PIL import Image\n",
    "\n",
    "# 用户指定模型，默认会被加载到当前路径下。 \n",
    "MODEL_PATH = \"/eas/workspace/model/\"\n",
    "\n",
    "class NumpyEncoder(json.JSONEncoder):\n",
    "\n",
    "    def default(self, obj):\n",
    "        if isinstance(obj, np.ndarray):\n",
    "            return obj.tolist()\n",
    "        elif isinstance(obj, np.generic):\n",
    "            return obj.item()\n",
    "        else:\n",
    "            return json.JSONEncoder.default(self, obj)\n",
    "\n",
    "app = FastAPI()\n",
    "\n",
    "@app.post(\"/\")\n",
    "async def predict(request: Request):\n",
    "    global p\n",
    "    content = await request.body()\n",
    "    img = Image.open(io.BytesIO(content))\n",
    "    res = p(img)\n",
    "    return Response(content=json.dumps(res, cls=NumpyEncoder), media_type=\"application/json\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    p = pipeline(\n",
    "        Tasks.image_classification,\n",
    "        model=MODEL_PATH,\n",
    "    )\n",
    "    uvicorn.run(app, host='0.0.0.0', port=8000)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 创建推理服务\n",
    "\n",
    "我们将使用PAI提供的ModelScope推理镜像，使用以上的推理服务程序，创建一个推理服务。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pai.modelscope import ModelScopeModel\n",
    "\n",
    "\n",
    "m = ModelScopeModel(\n",
    "    # 使用以上训练作业产出的模型\n",
    "    model_data=est.model_data(),\n",
    "    modelscope_version=\"latest\",\n",
    "    # 配置模型的推理配置，包括使用的镜像，使用的推理服务脚本，推理的依赖包等。\n",
    "    source_dir=\"./serve_src/\",\n",
    "    command=\"python run.py\",\n",
    "    requirements=[\n",
    "        \"fastapi\",\n",
    "        \"uvicorn\",\n",
    "    ],\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "指定推理服务的名称，以及使用的机器实例规格，创建一个推理服务。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "da9bcabacb37416cb88cfd06d2a159fa",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Uploading file: serve_src/run.py:   0%|          | 0.00/1.04k [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "View the service detail by accessing the console URI: \n",
      "https://pai.console.aliyun.com/?regionId=cn-hangzhou#/eas/serviceDetail/modelscope_vit_ismbhx4d/detail\n"
     ]
    }
   ],
   "source": [
    "from pai.predictor import Predictor\n",
    "from pai.common.utils import random_str\n",
    "\n",
    "\n",
    "p: Predictor = m.deploy(\n",
    "    service_name=\"modelscope_vit_{}\".format(random_str(8)),\n",
    "    instance_type=\"ecs.c6.xlarge\",\n",
    "    options={\n",
    "        # 推理镜像较大的镜像下，需要配置额外的磁盘空间\n",
    "        \"features.eas.aliyun.com/extra-ephemeral-storage\": \"40GB\"\n",
    "    },\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`model.deploy` 返回的`Predictor`对象可以用于向相应的推理服务发送请求，获得推理结果。\n",
    "\n",
    "\n",
    "这里我们使用已经准备的一张花朵图片测试推理服务。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=256x256>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import io\n",
    "\n",
    "import requests\n",
    "from PIL import Image\n",
    "from IPython import display\n",
    "\n",
    "url = \"https://pai-sdk.oss-cn-shanghai.aliyuncs.com/resources/images/11563567033_b822736d84_c.jpeg\"\n",
    "\n",
    "data = requests.get(url).content\n",
    "\n",
    "display.display(Image.open(io.BytesIO(data)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pai.predictor import RawResponse\n",
    "\n",
    "resp: RawResponse = p.raw_predict(data=data)\n",
    "\n",
    "print(resp.json())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "在测试完成之后，我们可以将创建的服务删除。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p.delete_service()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pai-dev-py38",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
